{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "2b4c85ee",
   "metadata": {},
   "source": [
    "# Full DB Updates Benchmark Notebook\n",
    "This notebook runs full-database update benchmarks for SQLite, MongoDB, and ParquetDB\n",
    "across varying numbers of initial records, then plots the update times with a log–log inset.\n",
    "\n",
    "## Benchmark Details\n",
    "- **Data Generation:** For *N* initial rows × 100 columns, integers 0–1,000,000 with a primary key `id` in column 0.\n",
    "- **Workflow:**\n",
    "  1. Create an empty database and insert N rows.\n",
    "  2. Read all rows to ensure data is loaded.\n",
    "  3. Generate N new rows (same `id`s) and perform bulk update of every row.\n",
    "- **Parquet Normalization (defaults):** row-group size 50,000–100,000 rows, max rows per file 10,000,000.\n",
    "\n",
    "## System Specifications\n",
    "- **Operating System:** Windows 10  \n",
    "- **Processor:** AMD Ryzen 7 3700X 8‑Core @ 3.6 MHz (8 cores, 16 logical processors)  \n",
    "- **Memory:** 128 GB DDR4‑3600 MHz (4×32 GB DIMMs) \n",
    "- **Storage**: SATA HDD 2TB (Model: ST2000DM008-2FR102)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "73cb2df5",
   "metadata": {},
   "source": [
    "## 1. Setup\n",
    "Import libraries, define directories, and parameters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7ccd3e20",
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip install parquetdb\n",
    "!pip install pymongo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "0e87ab2b",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import time\n",
    "import random\n",
    "import shutil\n",
    "import sqlite3\n",
    "import pandas as pd\n",
    "from pymongo import MongoClient, UpdateOne\n",
    "from parquetdb import ParquetDB, config\n",
    "from parquetdb.utils import general_utils\n",
    "\n",
    "# Directories\n",
    "bench_dir = os.path.join(config.data_dir, 'benchmarks')\n",
    "sqlite_dir = os.path.join(bench_dir, 'sqlite')\n",
    "mongo_dir  = os.path.join(bench_dir, 'mongodb')\n",
    "pq_dir     = os.path.join(bench_dir, 'parquetdb')\n",
    "for d in (sqlite_dir, mongo_dir, pq_dir): os.makedirs(d, exist_ok=True)\n",
    "\n",
    "# Row counts to test\n",
    "row_counts = [1, 10, 100, 1000, 10000, 100000, 1000000]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ea52978",
   "metadata": {},
   "source": [
    "## 2. SQLite Full DB Update Benchmark"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "6c387804",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SQLite 1: create=0.000s, read=0.000s, update=0.075s\n",
      "SQLite 10: create=0.001s, read=0.000s, update=0.092s\n",
      "SQLite 100: create=0.001s, read=0.002s, update=0.091s\n",
      "SQLite 1000: create=0.007s, read=0.017s, update=0.095s\n",
      "SQLite 10000: create=0.074s, read=0.158s, update=0.464s\n",
      "SQLite 100000: create=0.697s, read=1.617s, update=6.933s\n",
      "SQLite 1000000: create=7.240s, read=16.668s, update=81.414s\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>n_rows</th>\n",
       "      <th>create_times</th>\n",
       "      <th>read_times</th>\n",
       "      <th>update_times</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.074734</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>10</td>\n",
       "      <td>0.000999</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.092107</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>100</td>\n",
       "      <td>0.001003</td>\n",
       "      <td>0.002000</td>\n",
       "      <td>0.091275</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1000</td>\n",
       "      <td>0.007365</td>\n",
       "      <td>0.016997</td>\n",
       "      <td>0.095235</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>10000</td>\n",
       "      <td>0.074001</td>\n",
       "      <td>0.158196</td>\n",
       "      <td>0.464167</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   n_rows  create_times  read_times  update_times\n",
       "0       1      0.000000    0.000000      0.074734\n",
       "1      10      0.000999    0.000000      0.092107\n",
       "2     100      0.001003    0.002000      0.091275\n",
       "3    1000      0.007365    0.016997      0.095235\n",
       "4   10000      0.074001    0.158196      0.464167"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def generate_data_sqlite(num_rows, n_columns=100):\n",
    "    return [(i,) + tuple(random.randint(0,1000000) for _ in range(n_columns-1))\n",
    "            for i in range(num_rows)]\n",
    "\n",
    "def remove_db_file(path):\n",
    "    if os.path.exists(path): os.remove(path)\n",
    "\n",
    "def benchmark_full_update_sqlite(num_rows, db_path):\n",
    "    # remove & insert\n",
    "    remove_db_file(db_path)\n",
    "    data = generate_data_sqlite(num_rows)\n",
    "    conn = sqlite3.connect(db_path)\n",
    "    cols = ', '.join(f'col{i} INTEGER' for i in range(100))\n",
    "    conn.execute(f'CREATE TABLE test_table ({cols})')\n",
    "    conn.execute('PRAGMA synchronous = OFF')\n",
    "    conn.execute('PRAGMA journal_mode = MEMORY')\n",
    "    ph = ', '.join('?' for _ in range(100))\n",
    "    start = time.time()\n",
    "    conn.executemany(f'INSERT INTO test_table VALUES ({ph})', data)\n",
    "    conn.commit()\n",
    "    insert_time = time.time() - start\n",
    "    conn.close()\n",
    "    # index & read\n",
    "    conn = sqlite3.connect(db_path)\n",
    "    conn.execute('CREATE INDEX idx_col0 ON test_table(col0)')\n",
    "    start = time.time()\n",
    "    rows = conn.execute('SELECT * FROM test_table').fetchall()\n",
    "    read_time = time.time() - start\n",
    "    # update\n",
    "    update_data = generate_data_sqlite(num_rows)\n",
    "    vals = [row[1:]+(row[0],) for row in update_data]\n",
    "    uq = 'UPDATE test_table SET ' + ', '.join(f'col{i}=?' for i in range(1,100)) + ' WHERE col0=?'\n",
    "    start = time.time()\n",
    "    conn.executemany(uq, vals)\n",
    "    conn.commit()\n",
    "    update_time = time.time() - start\n",
    "    conn.close()\n",
    "    return insert_time, read_time, update_time\n",
    "\n",
    "# run for all row_counts\n",
    "db_file = os.path.join(sqlite_dir, 'benchmark.db')\n",
    "results_sql = {'n_rows': [], 'create_times': [], 'read_times': [], 'update_times': []}\n",
    "for n in row_counts:\n",
    "    ct, rt, ut = benchmark_full_update_sqlite(n, db_file)\n",
    "    results_sql['n_rows'].append(n)\n",
    "    results_sql['create_times'].append(ct)\n",
    "    results_sql['read_times'].append(rt)\n",
    "    results_sql['update_times'].append(ut)\n",
    "    print(f'SQLite {n}: create={ct:.3f}s, read={rt:.3f}s, update={ut:.3f}s')\n",
    "df_sql = pd.DataFrame(results_sql)\n",
    "df_sql.to_csv(os.path.join(sqlite_dir, 'sqlite_full_update_benchmark.csv'), index=False)\n",
    "df_sql.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a03c2d4c",
   "metadata": {},
   "source": [
    "## 3. MongoDB Full DB Update Benchmark"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "e4b11d48",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MongoDB 1: create=0.014s, read=0.001s, update=0.010s\n",
      "MongoDB 10: create=0.012s, read=0.000s, update=0.018s\n",
      "MongoDB 100: create=0.015s, read=0.002s, update=0.037s\n",
      "MongoDB 1000: create=0.034s, read=0.020s, update=0.303s\n",
      "MongoDB 10000: create=0.249s, read=0.333s, update=2.842s\n",
      "MongoDB 100000: create=3.431s, read=2.599s, update=32.462s\n",
      "MongoDB 1000000: create=37.325s, read=32.851s, update=321.679s\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>n_rows</th>\n",
       "      <th>create_times</th>\n",
       "      <th>read_times</th>\n",
       "      <th>update_times</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>0.013534</td>\n",
       "      <td>0.000532</td>\n",
       "      <td>0.010231</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>10</td>\n",
       "      <td>0.011519</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.018000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>100</td>\n",
       "      <td>0.014620</td>\n",
       "      <td>0.002000</td>\n",
       "      <td>0.036607</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1000</td>\n",
       "      <td>0.034001</td>\n",
       "      <td>0.020013</td>\n",
       "      <td>0.303171</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>10000</td>\n",
       "      <td>0.249194</td>\n",
       "      <td>0.332625</td>\n",
       "      <td>2.841995</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   n_rows  create_times  read_times  update_times\n",
       "0       1      0.013534    0.000532      0.010231\n",
       "1      10      0.011519    0.000000      0.018000\n",
       "2     100      0.014620    0.002000      0.036607\n",
       "3    1000      0.034001    0.020013      0.303171\n",
       "4   10000      0.249194    0.332625      2.841995"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def generate_data_mongo(num_rows, n_columns=100):\n",
    "    data = []\n",
    "    for i in range(num_rows):\n",
    "        doc = {'id': i}\n",
    "        doc.update({f'col{j}': random.randint(0,1000000) for j in range(n_columns)})\n",
    "        data.append(doc)\n",
    "    return data\n",
    "\n",
    "def benchmark_full_update_mongo(num_rows, client, db_name='benchmark'):\n",
    "    client.drop_database(db_name)\n",
    "    data = generate_data_mongo(num_rows)\n",
    "    coll = client[db_name].test_collection\n",
    "    start = time.time(); coll.insert_many(data); ct = time.time()-start\n",
    "    coll.create_index('id', unique=True)\n",
    "    start = time.time(); list(coll.find({})); rt = time.time()-start\n",
    "    upd = generate_data_mongo(num_rows)\n",
    "    ops = [UpdateOne({'id':d['id']},{'$set':{k:v for k,v in d.items() if k!='id'}}) for d in upd]\n",
    "    start = time.time(); coll.bulk_write(ops); ut = time.time()-start\n",
    "    return ct, rt, ut\n",
    "\n",
    "client = MongoClient('mongodb://localhost:27017/')\n",
    "results_mg = {'n_rows': [], 'create_times': [], 'read_times': [], 'update_times': []}\n",
    "for n in row_counts:\n",
    "    ct, rt, ut = benchmark_full_update_mongo(n, client)\n",
    "    results_mg['n_rows'].append(n)\n",
    "    results_mg['create_times'].append(ct)\n",
    "    results_mg['read_times'].append(rt)\n",
    "    results_mg['update_times'].append(ut)\n",
    "    print(f'MongoDB {n}: create={ct:.3f}s, read={rt:.3f}s, update={ut:.3f}s')\n",
    "df_mg = pd.DataFrame(results_mg)\n",
    "df_mg.to_csv(os.path.join(mongo_dir, 'mongodb_full_update_benchmark.csv'), index=False)\n",
    "client.close()\n",
    "df_mg.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3645b8ab",
   "metadata": {},
   "source": [
    "## 4. ParquetDB Full DB Update Benchmark"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "8b817121",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[INFO] 2025-04-19 14:39:26 - parquetdb.core.parquetdb[205][__init__] - Initializing ParquetDB with db_path: Z:\\data\\parquetdb\\data\\benchmarks\\parquetdb\\BenchmarkDB\n",
      "[INFO] 2025-04-19 14:39:26 - parquetdb.core.parquetdb[207][__init__] - verbose: 1\n",
      "ParquetDB 1: create=0.069s, read=0.018s, update=0.063s\n",
      "ParquetDB 10: create=0.044s, read=0.014s, update=0.064s\n",
      "ParquetDB 100: create=0.054s, read=0.015s, update=0.064s\n",
      "ParquetDB 1000: create=0.072s, read=0.014s, update=0.088s\n",
      "ParquetDB 10000: create=0.307s, read=0.019s, update=0.339s\n",
      "ParquetDB 100000: create=2.611s, read=0.063s, update=2.958s\n",
      "ParquetDB 1000000: create=22.248s, read=0.325s, update=29.480s\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>n_rows</th>\n",
       "      <th>create_times</th>\n",
       "      <th>read_times</th>\n",
       "      <th>update_times</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>0.069068</td>\n",
       "      <td>0.017998</td>\n",
       "      <td>0.063001</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>10</td>\n",
       "      <td>0.044004</td>\n",
       "      <td>0.014008</td>\n",
       "      <td>0.064009</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>100</td>\n",
       "      <td>0.053879</td>\n",
       "      <td>0.015185</td>\n",
       "      <td>0.064248</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1000</td>\n",
       "      <td>0.072003</td>\n",
       "      <td>0.013999</td>\n",
       "      <td>0.087530</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>10000</td>\n",
       "      <td>0.307071</td>\n",
       "      <td>0.018996</td>\n",
       "      <td>0.338519</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   n_rows  create_times  read_times  update_times\n",
       "0       1      0.069068    0.017998      0.063001\n",
       "1      10      0.044004    0.014008      0.064009\n",
       "2     100      0.053879    0.015185      0.064248\n",
       "3    1000      0.072003    0.013999      0.087530\n",
       "4   10000      0.307071    0.018996      0.338519"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "db_path = os.path.join(pq_dir, 'BenchmarkDB')\n",
    "if os.path.exists(db_path): shutil.rmtree(db_path)\n",
    "db = ParquetDB(db_path)\n",
    "def benchmark_full_update_pq(num_rows):\n",
    "    data = general_utils.generate_pylist_data(n_rows=num_rows, min_value=0, max_value=1000000)\n",
    "    start = time.time(); db.create(data); ct=time.time()-start\n",
    "    start = time.time(); _=db.read(); rt=time.time()-start\n",
    "    upd = general_utils.generate_pylist_update_data(n_rows=num_rows, min_value=0, max_value=1000000)\n",
    "    start = time.time(); db.update(upd); ut=time.time()-start\n",
    "    return ct, rt, ut\n",
    "\n",
    "results_pq = {'n_rows': [], 'create_times': [], 'read_times': [], 'update_times': []}\n",
    "for n in row_counts:\n",
    "    ct, rt, ut = benchmark_full_update_pq(n)\n",
    "    results_pq['n_rows'].append(n)\n",
    "    results_pq['create_times'].append(ct)\n",
    "    results_pq['read_times'].append(rt)\n",
    "    results_pq['update_times'].append(ut)\n",
    "    print(f'ParquetDB {n}: create={ct:.3f}s, read={rt:.3f}s, update={ut:.3f}s')\n",
    "df_pq = pd.DataFrame(results_pq)\n",
    "df_pq.to_csv(os.path.join(pq_dir, 'parquetdb_full_update_benchmark.csv'), index=False)\n",
    "df_pq.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b6c2796a",
   "metadata": {},
   "source": [
    "## 5. Load and Preview Results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "924e3b76",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(   n_rows  create_times  read_times  update_times\n",
       " 0       1      0.000000    0.000000      0.074734\n",
       " 1      10      0.000999    0.000000      0.092107\n",
       " 2     100      0.001003    0.002000      0.091275\n",
       " 3    1000      0.007365    0.016997      0.095235\n",
       " 4   10000      0.074001    0.158196      0.464167,\n",
       "    n_rows  create_times  read_times  update_times\n",
       " 0       1      0.013534    0.000532      0.010231\n",
       " 1      10      0.011519    0.000000      0.018000\n",
       " 2     100      0.014620    0.002000      0.036607\n",
       " 3    1000      0.034001    0.020013      0.303171\n",
       " 4   10000      0.249194    0.332625      2.841995,\n",
       "    n_rows  create_times  read_times  update_times\n",
       " 0       1      0.069068    0.017998      0.063001\n",
       " 1      10      0.044004    0.014008      0.064009\n",
       " 2     100      0.053879    0.015185      0.064248\n",
       " 3    1000      0.072003    0.013999      0.087530\n",
       " 4   10000      0.307071    0.018996      0.338519)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_sql = pd.read_csv(os.path.join(sqlite_dir, \"sqlite_full_update_benchmark.csv\"))\n",
    "df_mg = pd.read_csv(os.path.join(mongo_dir, \"mongodb_full_update_benchmark.csv\"))\n",
    "df_pq = pd.read_csv(os.path.join(pq_dir, \"parquetdb_full_update_benchmark.csv\"))\n",
    "\n",
    "df_sql.head(), df_mg.head(), df_pq.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "34f387a3",
   "metadata": {},
   "source": [
    "## 6. Plot Update Times\n",
    "Plot update times vs. number of rows for each backend with a log–log inset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "604b5c6d",
   "metadata": {
    "tags": [
     "nbsphinx-thumbnail"
    ]
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\lllang\\AppData\\Local\\Temp\\ipykernel_46708\\3152547411.py:131: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n",
      "  plt.tight_layout()\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.ticker as ticker\n",
    "from mpl_toolkits.axes_grid1.inset_locator import inset_axes\n",
    "\n",
    "n_rows = df_pq[\"n_rows\"]\n",
    "colors = {'sqlite':'#e52207','mongodb':'#e5a000','parquetdb':'#59b9de'}\n",
    "markers = {'sqlite':'o','mongodb':'o','parquetdb':'o'}\n",
    "fill = {'sqlite':'full','mongodb':'full','parquetdb':'full'}\n",
    "\n",
    "fig, ax1 = plt.subplots(figsize=(10,6))\n",
    "    \n",
    "ax1.plot(\n",
    "    n_rows,\n",
    "    df_sql[\"update_times\"],\n",
    "    label=\"sqlite\",\n",
    "    color=colors[\"sqlite\"],\n",
    "    linestyle=\"solid\",\n",
    "    marker=markers[\"sqlite\"],\n",
    "    fillstyle=fill[\"sqlite\"],\n",
    ")\n",
    "\n",
    "ax1.plot(\n",
    "    n_rows,\n",
    "    df_mg[\"update_times\"],\n",
    "    label=\"mongodb\",\n",
    "    color=colors[\"mongodb\"],\n",
    "    linestyle=\"solid\",\n",
    "    marker=markers[\"mongodb\"],\n",
    "    fillstyle=fill[\"mongodb\"],\n",
    ")\n",
    "\n",
    "ax1.plot(\n",
    "    n_rows,\n",
    "    df_pq[\"update_times\"],\n",
    "    label=\"parquetdb\",\n",
    "    color=colors[\"parquetdb\"],\n",
    "    linestyle=\"solid\",\n",
    "    marker=markers[\"parquetdb\"],\n",
    "    fillstyle=fill[\"parquetdb\"],\n",
    ")\n",
    "    \n",
    "\n",
    "ax1.set_xlabel('Number of Rows')\n",
    "ax1.set_ylabel('Update Times (s)')\n",
    "ax1.grid(True)\n",
    "ax1.spines[\"left\"].set_linestyle(\"solid\")\n",
    "ax1.spines[\"left\"].set_linewidth(2.5)\n",
    "ax1.tick_params(axis=\"both\", which=\"major\", length=10, width=2, direction=\"out\")\n",
    "\n",
    "scale = 36\n",
    "ax_inset = inset_axes(\n",
    "    ax1,\n",
    "    width=f\"{scale}%\",\n",
    "    height=f\"{scale}%\",\n",
    "    loc=\"upper left\",\n",
    "    bbox_to_anchor=(0.05, -0.03, 1, 1),\n",
    "    bbox_transform=ax1.transAxes,\n",
    "    borderpad=2,\n",
    ")\n",
    "\n",
    "ax_inset.grid(True)\n",
    "\n",
    "\n",
    "\n",
    "ax_inset.plot(\n",
    "    n_rows,\n",
    "    df_sql[\"update_times\"],\n",
    "    label=\"sqlite\",\n",
    "    color=colors[\"sqlite\"],\n",
    "    linestyle=\"solid\",\n",
    "    marker=markers[\"sqlite\"],\n",
    "    fillstyle=fill[\"sqlite\"],\n",
    ")\n",
    "\n",
    "ax_inset.plot(\n",
    "    n_rows,\n",
    "    df_mg[\"update_times\"],\n",
    "    label=\"mongodb\",\n",
    "    color=colors[\"mongodb\"],\n",
    "    linestyle=\"solid\",\n",
    "    marker=markers[\"mongodb\"],\n",
    "    fillstyle=fill[\"mongodb\"],\n",
    ")\n",
    "\n",
    "ax_inset.plot(\n",
    "    n_rows,\n",
    "    df_pq[\"update_times\"],\n",
    "    label=\"parquetdb\",\n",
    "    color=colors[\"parquetdb\"],\n",
    "    linestyle=\"solid\",\n",
    "    marker=markers[\"parquetdb\"],\n",
    "    fillstyle=fill[\"parquetdb\"],\n",
    ")\n",
    "    \n",
    "\n",
    "# Set log scale for both axes in the inset\n",
    "ax_inset.set_xscale(\"log\")\n",
    "ax_inset.set_yscale(\"log\")\n",
    "\n",
    "# Set labels for inset plot\n",
    "ax_inset.set_xlabel(\"Number of Rows (log)\", fontsize=8)\n",
    "ax_inset.set_ylabel(\"Update Time (log)\", fontsize=8, labelpad=-2)\n",
    "# ax_inset2.set_ylabel('Read Time (log)', fontsize=8)\n",
    "\n",
    "nticks = 9\n",
    "maj_loc = ticker.LogLocator(numticks=nticks)\n",
    "min_loc = ticker.LogLocator(subs=\"all\", numticks=nticks)\n",
    "ax_inset.xaxis.set_major_locator(maj_loc)\n",
    "ax_inset.xaxis.set_minor_locator(min_loc)\n",
    "\n",
    "# Set the same linestyle and make the spine thicker for visibility\n",
    "ax_inset.spines[\"left\"].set_linestyle(\"solid\")\n",
    "ax_inset.spines[\"left\"].set_linewidth(2.5)  # Increase the line width for visibility\n",
    "\n",
    "# Hide the right spine on ax1 and left spine on ax2 to prevent overlap\n",
    "# ax_inset.spines['right'].set_visible(False)\n",
    "\n",
    "ax_inset.tick_params(\n",
    "    axis=\"both\", which=\"major\", length=6, width=1.5, direction=\"out\"\n",
    ")\n",
    "ax_inset.tick_params(axis=\"x\", which=\"minor\", length=3, width=1, direction=\"out\")\n",
    "ax_inset.tick_params(axis=\"y\", which=\"minor\", length=3, width=1, direction=\"out\")\n",
    "\n",
    "lines_1, labels_1 = ax1.get_legend_handles_labels()\n",
    "\n",
    "ax1.legend(lines_1, labels_1, loc=\"upper center\", bbox_to_anchor=(0.12, 0, 1, 1))\n",
    "\n",
    "ax1.set_title(\n",
    "    \"Update Benchmark: \\n SQLite, MongoDB, and ParquetDB with 100 integer columns\"\n",
    ")\n",
    "plt.tight_layout()\n",
    "plt.savefig(os.path.join(bench_dir,\"full-db-updates_benchmark.pdf\"))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b40b711d",
   "metadata": {},
   "source": [
    "## 6. Dicussion\n",
    "\n",
    "1. **Full‑table rewrite cost**  \n",
    "   - All three engines must rewrite every row during a full‑database update, but their architectures yield very different throughput.\n",
    "\n",
    "2. **Absolute performance ranking**  \n",
    "   - **ParquetDB** is fastest at scale—even though it pays a nontrivial **~8–10 s** baseline cost to rewrite its first row‑group, it then applies multithreaded, columnar writes to all subsequent groups.  \n",
    "   - **SQLite** comes in 2nd with its single‑threaded C‑API calls performing ~80 s at 1 M rows.  \n",
    "   - **MongoDB** trails at ~320 s for 1 M, due to BSON encoding and driver overhead.\n",
    "\n",
    "3. **Three scaling regimes**  \n",
    "   - **ParquetDB**  \n",
    "     - **Flat region** up to ~100 K rows (1 row‑group) ⇒ constant‐time rewrite of the single group (~8 s).  \n",
    "     - **Parallel slope** beyond ~100 K ⇒ each new 50–100 K‑row group adds only ~2–3 s, thanks to multithreading and column‑statistics skipping.  \n",
    "   - **SQLite & MongoDB**  \n",
    "     - **Linear** scaling: each extra 100 K rows adds ~15 s (SQLite) or ~60 s (MongoDB), reflecting per‑row update loops in a single thread.\n",
    "\n",
    "5. **Key takeaway**  \n",
    "   - For **large‑scale full‑table updates**, ParquetDB’s columnar, multi‑group rewrite shines—unmatched by traditional row‑stores once you exceed the first row‑group.  \n",
    "   - For **tiny updates** (< 50 K rows), row‑stores still avoid file‑level overhead, but beyond that threshold ParquetDB pulls ahead decisively.\n",
    "\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "parquetdb_dev",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.20"
  },
  "nbsphinx": {
   "execute": "never"
  },
  "nbsphinx-thumbnail": {
   "tooltip": "In this example, we benchmark the performance for full DB updates vs varying number of rows in ParquetDB vs. SQLite and MongoDB."
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
